ARG_CHILD
};
-typedef struct _GtkLArgInfo GtkLArgInfo;
-struct _GtkLArgInfo
+typedef struct _GtkChildArgInfo GtkChildArgInfo;
+struct _GtkChildArgInfo
{
gchar *name;
GtkType type;
static void gtk_container_hide_all (GtkWidget *widget);
GtkArg* gtk_object_collect_args (guint *n_args,
+ GtkType (*) (const gchar*),
va_list args1,
va_list args2);
static guint container_signals[LAST_SIGNAL] = { 0 };
-static GHashTable *arg_info_ht = NULL;
+static GHashTable *child_arg_info_ht = NULL;
static GtkWidgetClass *parent_class = NULL;
guint arg_flags,
guint arg_id)
{
- GtkLArgInfo *info;
+ GtkChildArgInfo *info;
gchar class_part[1024];
gchar *arg_part;
GtkType class_type;
return;
}
- info = g_new (GtkLArgInfo, 1);
+ info = g_new (GtkChildArgInfo, 1);
info->name = g_strdup (arg_name);
info->type = arg_type;
info->class_type = class_type;
info->arg_id = arg_id;
info->seq_id = ++((GtkContainerClass*) gtk_type_class (class_type))->n_child_args;
- if (!arg_info_ht)
- arg_info_ht = g_hash_table_new (g_str_hash, g_str_equal);
+ if (!child_arg_info_ht)
+ child_arg_info_ht = g_hash_table_new (g_str_hash, g_str_equal);
- g_hash_table_insert (arg_info_ht, info->name, info);
+ g_hash_table_insert (child_arg_info_ht, info->name, info);
}
typedef struct
{
GList *arg_list;
GtkType class_type;
-} GtkQueryLArgData;
+} GtkQueryChildArgData;
static void
-gtk_query_larg_foreach (gpointer key,
- gpointer value,
- gpointer user_data)
+gtk_query_child_arg_foreach (gpointer key,
+ gpointer value,
+ gpointer user_data)
{
- register GtkLArgInfo *info;
- register GtkQueryLArgData *data;
+ register GtkChildArgInfo *info;
+ register GtkQueryChildArgData *data;
info = value;
data = user_data;
data->arg_list = g_list_prepend (data->arg_list, info);
}
+GtkType
+gtk_container_get_child_arg_type (const gchar *arg_name)
+{
+ GtkChildArgInfo *info;
+ gchar buffer[128];
+ gchar *t;
+
+ g_return_val_if_fail (arg_name != NULL, 0);
+
+ if (!child_arg_info_ht)
+ return GTK_TYPE_INVALID;
+
+ if (!arg_name || strlen (arg_name) > 120)
+ {
+ /* security audit
+ */
+ g_warning ("gtk_container_get_child_arg_type(): argument `arg_name' exceeds maximum size.");
+ return GTK_TYPE_INVALID;
+ }
+
+ t = strchr (arg_name, ':');
+ if (!t || (t[0] != ':') || (t[1] != ':'))
+ {
+ g_warning ("gtk_container_get_child_arg_type(): invalid arg name: \"%s\"\n", arg_name);
+ return GTK_TYPE_INVALID;
+ }
+
+ t = strchr (t + 2, ':');
+ if (t)
+ {
+ strncpy (buffer, arg_name, (long) (t - arg_name));
+ buffer[(long) (t - arg_name)] = '\0';
+ arg_name = buffer;
+ }
+
+ info = g_hash_table_lookup (child_arg_info_ht, arg_name);
+ if (info)
+ return info->type;
+
+ return GTK_TYPE_INVALID;
+}
+
GtkArg*
gtk_container_query_child_args (GtkType class_type,
guint32 **arg_flags,
guint *n_args)
{
GtkArg *args;
- GtkQueryLArgData query_data;
+ GtkQueryChildArgData query_data;
if (arg_flags)
*arg_flags = NULL;
*n_args = 0;
g_return_val_if_fail (gtk_type_is_a (class_type, GTK_TYPE_CONTAINER), NULL);
- if (!arg_info_ht)
+ if (!child_arg_info_ht)
return NULL;
/* make sure the types class has been initialized, because
query_data.arg_list = NULL;
query_data.class_type = class_type;
- g_hash_table_foreach (arg_info_ht, gtk_query_larg_foreach, &query_data);
+ g_hash_table_foreach (child_arg_info_ht, gtk_query_child_arg_foreach, &query_data);
if (query_data.arg_list)
{
do
{
- GtkLArgInfo *info;
+ GtkChildArgInfo *info;
info = list->data;
list = list->prev;
g_return_if_fail (child != NULL);
g_return_if_fail (GTK_IS_WIDGET (child));
- if (!arg_info_ht)
+ if (!child_arg_info_ht)
return;
for (i = 0; i < n_args; i++)
{
- GtkLArgInfo *info;
+ GtkChildArgInfo *info;
gchar *lookup_name;
gchar *d;
if (d)
*d = 0;
- info = g_hash_table_lookup (arg_info_ht, lookup_name);
+ info = g_hash_table_lookup (child_arg_info_ht, lookup_name);
}
else
info = NULL;
}
}
+void
+gtk_container_child_arg_set (GtkContainer *container,
+ GtkWidget *child,
+ ...)
+{
+ GtkArg *args;
+ guint n_args;
+ va_list args1;
+ va_list args2;
+
+ g_return_if_fail (container != NULL);
+ g_return_if_fail (GTK_IS_CONTAINER (container));
+ g_return_if_fail (child != NULL);
+ g_return_if_fail (GTK_IS_WIDGET (child));
+ g_return_if_fail (child->parent != NULL);
+
+ va_start (args1, child);
+ va_start (args2, child);
+
+ args = gtk_object_collect_args (&n_args, gtk_container_get_child_arg_type, args1, args2);
+ gtk_container_child_arg_setv (container, child, n_args, args);
+ g_free (args);
+
+ va_end (args1);
+ va_end (args2);
+}
+
void
gtk_container_child_arg_setv (GtkContainer *container,
GtkWidget *child,
g_return_if_fail (child != NULL);
g_return_if_fail (GTK_IS_WIDGET (child));
- if (!arg_info_ht)
+ if (!child_arg_info_ht)
return;
for (i = 0; i < n_args; i++)
{
- GtkLArgInfo *info;
+ GtkChildArgInfo *info;
gchar *lookup_name;
gchar *d;
gboolean arg_ok;
if (d)
*d = 0;
- info = g_hash_table_lookup (arg_info_ht, lookup_name);
+ info = g_hash_table_lookup (child_arg_info_ht, lookup_name);
}
else
info = NULL;
va_start (args1, widget);
va_start (args2, widget);
- args = gtk_object_collect_args (&n_args, args1, args2);
+ args = gtk_object_collect_args (&n_args, gtk_container_get_child_arg_type, args1, args2);
gtk_container_child_arg_setv (container, widget, n_args, args);
g_free (args);
GtkType arg_type,
guint arg_flags,
guint arg_id);
-
+GtkType gtk_container_get_child_arg_type (const gchar *arg_name);
+
/* Allocate a GtkArg array of size nargs that hold the
* names and types of the args that can be used with
- * gtk_container_child_arg_get/gtk_container_child_arg_set.
+ * gtk_container_child_arg_getv/gtk_container_child_arg_setv.
* if (arg_flags!=NULL),
* (*arg_flags) will be set to point to a newly allocated
* guint array that holds the flags of the args.
GtkWidget *widget,
guint n_args,
GtkArg *args);
-
+void gtk_container_child_arg_set (GtkContainer *container,
+ GtkWidget *child,
+ ...);
+
/* Non-public methods */
void gtk_container_queue_resize (GtkContainer *container);
GdkDrawable *drawable);
static void gtk_entry_style_set (GtkWidget *widget,
GtkStyle *previous_style);
+static void gtk_entry_state_changed (GtkWidget *widget,
+ GtkStateType previous_state);
static void gtk_entry_queue_draw (GtkEntry *entry);
static gint gtk_entry_timer (gpointer data);
static gint gtk_entry_position (GtkEntry *entry,
widget_class->key_press_event = gtk_entry_key_press;
widget_class->focus_in_event = gtk_entry_focus_in;
widget_class->focus_out_event = gtk_entry_focus_out;
- widget_class->style_set = gtk_entry_style_set;
+ widget_class->style_set = gtk_entry_style_set;
+ widget_class->state_changed = gtk_entry_state_changed;
editable_class->insert_text = gtk_entry_insert_text;
editable_class->delete_text = gtk_entry_delete_text;
widget->style = gtk_style_attach (widget->style, widget->window);
- gdk_window_set_background (widget->window, &widget->style->base[GTK_STATE_NORMAL]);
- gdk_window_set_background (entry->text_area, &widget->style->base[GTK_STATE_NORMAL]);
+ gdk_window_set_background (widget->window, &widget->style->base[GTK_WIDGET_STATE (widget)]);
+ gdk_window_set_background (entry->text_area, &widget->style->base[GTK_WIDGET_STATE (widget)]);
#ifdef USE_XIM
if (gdk_im_ready ())
else
{
gdk_draw_rectangle (widget->window,
- widget->style->base_gc[GTK_WIDGET_STATE(widget)],
+ widget->style->base_gc[GTK_WIDGET_STATE (widget)],
FALSE, x + 2, y + 2, width - 5, height - 5);
}
if (selection_start_pos > start_pos)
gdk_draw_text (drawable, widget->style->font,
- widget->style->fg_gc[GTK_STATE_NORMAL],
+ widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
start_xoffset, y,
toprint,
selection_start_pos - start_pos);
if (selection_end_pos < end_pos)
gdk_draw_text (drawable, widget->style->font,
- widget->style->fg_gc[GTK_STATE_NORMAL],
+ widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
selection_end_xoffset, y,
toprint + selection_end_pos - start_pos,
end_pos - selection_end_pos);
entry->scroll_offset = entry->char_offset[scroll_char];
gtk_entry_adjust_scroll (entry);
- gdk_window_set_background (widget->window, &widget->style->base[GTK_STATE_NORMAL]);
- gdk_window_set_background (entry->text_area, &widget->style->base[GTK_STATE_NORMAL]);
+ gdk_window_set_background (widget->window, &widget->style->base[GTK_WIDGET_STATE (widget)]);
+ gdk_window_set_background (entry->text_area, &widget->style->base[GTK_WIDGET_STATE (widget)]);
+ }
+
+ if (GTK_WIDGET_DRAWABLE (widget))
+ gdk_window_clear (widget->window);
+}
+
+static void
+gtk_entry_state_changed (GtkWidget *widget,
+ GtkStateType previous_state)
+{
+ g_return_if_fail (widget != NULL);
+ g_return_if_fail (GTK_IS_ENTRY (widget));
+
+ if (GTK_WIDGET_REALIZED (widget))
+ {
+ gdk_window_set_background (widget->window, &widget->style->base[GTK_WIDGET_STATE (widget)]);
+ gdk_window_set_background (GTK_ENTRY (widget)->text_area, &widget->style->base[GTK_WIDGET_STATE (widget)]);
}
if (GTK_WIDGET_DRAWABLE (widget))
GdkEventExpose *event);
-guint
+GtkType
gtk_event_box_get_type (void)
{
- static guint event_box_type = 0;
+ static GtkType event_box_type = 0;
if (!event_box_type)
{
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
#ifdef __cplusplus
extern "C" {
+#pragma }
#endif /* __cplusplus */
-#define GTK_EVENT_BOX(obj) GTK_CHECK_CAST (obj, gtk_event_box_get_type (), GtkEventBox)
-#define GTK_EVENT_BOX_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, gtk_event_box_get_type (), GtkEventBoxClass)
-#define GTK_IS_EVENT_BOX(obj) GTK_CHECK_TYPE (obj, gtk_event_box_get_type ())
+#define GTK_TYPE_EVENT_BOX (gtk_event_box_get_type ())
+#define GTK_EVENT_BOX(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_EVENT_BOX, GtkEventBox))
+#define GTK_EVENT_BOX_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_EVENT_BOX, GtkEventBoxClass))
+#define GTK_IS_EVENT_BOX(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_EVENT_BOX))
+#define GTK_IS_EVENT_BOX_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_EVENT_BOX))
-typedef struct _GtkEventBox GtkEventBox;
+typedef struct _GtkEventBox GtkEventBox;
typedef struct _GtkEventBoxClass GtkEventBoxClass;
struct _GtkEventBox
GtkBinClass parent_class;
};
-guint gtk_event_box_get_type (void);
-GtkWidget* gtk_event_box_new (void);
+GtkType gtk_event_box_get_type (void);
+GtkWidget* gtk_event_box_new (void);
#ifdef __cplusplus
}
gtk_misc_set_alignment (misc, misc->xalign, GTK_VALUE_DOUBLE (*arg));
break;
case ARG_XPAD:
- gtk_misc_set_alignment (misc, GTK_VALUE_INT (*arg), misc->ypad);
+ gtk_misc_set_padding (misc, GTK_VALUE_INT (*arg), misc->ypad);
break;
case ARG_YPAD:
- gtk_misc_set_alignment (misc, misc->xpad, GTK_VALUE_INT (*arg));
+ gtk_misc_set_padding (misc, misc->xpad, GTK_VALUE_INT (*arg));
break;
default:
break;
static void gtk_object_notify_weaks (GtkObject *object);
GtkArg* gtk_object_collect_args (guint *nargs,
+ GtkType (*) (const gchar*),
va_list args1,
va_list args2);
va_start (args1, type);
va_start (args2, type);
- args = gtk_object_collect_args (&nargs, args1, args2);
+ args = gtk_object_collect_args (&nargs, gtk_object_get_arg_type, args1, args2);
gtk_object_setv (obj, nargs, args);
g_free (args);
va_start (args1, object);
va_start (args2, object);
- args = gtk_object_collect_args (&nargs, args1, args2);
+ args = gtk_object_collect_args (&nargs, gtk_object_get_arg_type, args1, args2);
gtk_object_setv (object, nargs, args);
g_free (args);
gtk_object_get_arg_type (const gchar *arg_name)
{
GtkArgInfo *info;
- gchar buffer[1024];
+ gchar buffer[128];
gchar *t;
g_return_val_if_fail (arg_name != NULL, 0);
if (!arg_info_ht)
return GTK_TYPE_INVALID;
- if (!arg_name || strlen (arg_name) > 1000)
+ if (!arg_name || strlen (arg_name) > 120)
{
/* security audit
*/
g_warning ("gtk_object_get_arg_type(): argument `arg_name' exceeds maximum size.");
- return 0;
+ return GTK_TYPE_INVALID;
}
t = strchr (arg_name, ':');
if (!t || (t[0] != ':') || (t[1] != ':'))
{
- g_warning ("invalid arg name: \"%s\"\n", arg_name);
+ g_warning ("gtk_object_get_arg_type(): invalid arg name: \"%s\"\n", arg_name);
return GTK_TYPE_INVALID;
}
arg_name = buffer;
}
- info = g_hash_table_lookup (arg_info_ht, (gpointer) arg_name);
+ info = g_hash_table_lookup (arg_info_ht, arg_name);
if (info)
return info->type;
GtkArg*
gtk_object_collect_args (guint *nargs,
+ GtkType (*get_arg_type) (const gchar*),
va_list args1,
va_list args2)
{
continue;
}
- type = gtk_object_get_arg_type (name);
+ type = get_arg_type (name);
switch (GTK_FUNDAMENTAL_TYPE (type))
{
for (i = 0; i < n; i++)
{
args[i].name = va_arg (args2, char *);
- args[i].type = gtk_object_get_arg_type (args[i].name);
+ args[i].type = get_arg_type (args[i].name);
switch (GTK_FUNDAMENTAL_TYPE (args[i].type))
{
#include "gtkpacker.h"
+enum {
+ ARG_0,
+ ARG_SPACING,
+ ARG_D_BORDER_WIDTH,
+ ARG_D_PAD_X,
+ ARG_D_PAD_Y,
+ ARG_D_IPAD_X,
+ ARG_D_IPAD_Y
+};
+
+enum {
+ CHILD_ARG_0,
+ CHILD_ARG_SIDE,
+ CHILD_ARG_ANCHOR,
+ CHILD_ARG_EXPAND,
+ CHILD_ARG_FILL_X,
+ CHILD_ARG_FILL_Y,
+ CHILD_ARG_USE_DEFAULT,
+ CHILD_ARG_BORDER_WIDTH,
+ CHILD_ARG_PAD_X,
+ CHILD_ARG_PAD_Y,
+ CHILD_ARG_I_PAD_X,
+ CHILD_ARG_I_PAD_Y,
+ CHILD_ARG_POSITION
+};
+
static void gtk_packer_class_init (GtkPackerClass *klass);
static void gtk_packer_init (GtkPacker *packer);
static void gtk_packer_map (GtkWidget *widget);
static void gtk_packer_foreach (GtkContainer *container,
GtkCallback callback,
gpointer callback_data);
+static void gtk_packer_set_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id);
+static void gtk_packer_get_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id);
+static void gtk_packer_get_child_arg (GtkContainer *container,
+ GtkWidget *child,
+ GtkArg *arg,
+ guint arg_id);
+static void gtk_packer_set_child_arg (GtkContainer *container,
+ GtkWidget *child,
+ GtkArg *arg,
+ guint arg_id);
static GtkType gtk_packer_child_type (GtkContainer *container);
-
+
static GtkPackerClass *parent_class;
sizeof (GtkPackerClass),
(GtkClassInitFunc) gtk_packer_class_init,
(GtkObjectInitFunc) gtk_packer_init,
- (GtkArgSetFunc) NULL,
- (GtkArgGetFunc) NULL
+ (GtkArgSetFunc) gtk_packer_set_arg,
+ (GtkArgGetFunc) gtk_packer_get_arg
};
- packer_type = gtk_type_unique (gtk_container_get_type (), &packer_info);
+ packer_type = gtk_type_unique (GTK_TYPE_CONTAINER, &packer_info);
}
return packer_type;
widget_class = (GtkWidgetClass*) klass;
container_class = (GtkContainerClass*) klass;
- parent_class = gtk_type_class (gtk_container_get_type ());
+ parent_class = gtk_type_class (GTK_TYPE_CONTAINER);
+ gtk_object_add_arg_type ("GtkPacker::spacing", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_SPACING);
+ gtk_object_add_arg_type ("GtkPacker::default_border_width", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_D_BORDER_WIDTH);
+ gtk_object_add_arg_type ("GtkPacker::default_pad_x", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_D_PAD_X);
+ gtk_object_add_arg_type ("GtkPacker::default_pad_y", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_D_PAD_Y);
+ gtk_object_add_arg_type ("GtkPacker::default_ipad_x", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_D_IPAD_X);
+ gtk_object_add_arg_type ("GtkPacker::default_ipad_y", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_D_IPAD_Y);
+
+ gtk_container_add_child_arg_type ("GtkPacker::side", GTK_TYPE_SIDE_TYPE, GTK_ARG_READWRITE, CHILD_ARG_SIDE);
+ gtk_container_add_child_arg_type ("GtkPacker::anchor", GTK_TYPE_ANCHOR_TYPE, GTK_ARG_READWRITE, CHILD_ARG_ANCHOR);
+ gtk_container_add_child_arg_type ("GtkPacker::expand", GTK_TYPE_BOOL, GTK_ARG_READWRITE, CHILD_ARG_EXPAND);
+ gtk_container_add_child_arg_type ("GtkPacker::fill_x", GTK_TYPE_BOOL, GTK_ARG_READWRITE, CHILD_ARG_FILL_X);
+ gtk_container_add_child_arg_type ("GtkPacker::fill_y", GTK_TYPE_BOOL, GTK_ARG_READWRITE, CHILD_ARG_FILL_Y);
+ gtk_container_add_child_arg_type ("GtkPacker::use_default", GTK_TYPE_BOOL, GTK_ARG_READWRITE, CHILD_ARG_USE_DEFAULT);
+ gtk_container_add_child_arg_type ("GtkPacker::border_width", GTK_TYPE_UINT, GTK_ARG_READWRITE, CHILD_ARG_BORDER_WIDTH);
+ gtk_container_add_child_arg_type ("GtkPacker::pad_x", GTK_TYPE_UINT, GTK_ARG_READWRITE, CHILD_ARG_PAD_X);
+ gtk_container_add_child_arg_type ("GtkPacker::pad_y", GTK_TYPE_UINT, GTK_ARG_READWRITE, CHILD_ARG_PAD_Y);
+ gtk_container_add_child_arg_type ("GtkPacker::ipad_x", GTK_TYPE_UINT, GTK_ARG_READWRITE, CHILD_ARG_I_PAD_X);
+ gtk_container_add_child_arg_type ("GtkPacker::ipad_y", GTK_TYPE_UINT, GTK_ARG_READWRITE, CHILD_ARG_I_PAD_Y);
+ gtk_container_add_child_arg_type ("GtkPacker::position", GTK_TYPE_LONG, GTK_ARG_READWRITE, CHILD_ARG_POSITION);
+
widget_class->map = gtk_packer_map;
widget_class->unmap = gtk_packer_unmap;
widget_class->draw = gtk_packer_draw;
container_class->remove = gtk_packer_remove;
container_class->foreach = gtk_packer_foreach;
container_class->child_type = gtk_packer_child_type;
+ container_class->get_child_arg = gtk_packer_get_child_arg;
+ container_class->set_child_arg = gtk_packer_set_child_arg;
+}
+
+static void
+gtk_packer_set_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id)
+{
+ GtkPacker *packer;
+
+ packer = GTK_PACKER (object);
+
+ switch (arg_id)
+ {
+ case ARG_SPACING:
+ gtk_packer_set_spacing (packer, GTK_VALUE_UINT (*arg));
+ break;
+ case ARG_D_BORDER_WIDTH:
+ gtk_packer_set_default_border_width (packer, GTK_VALUE_UINT (*arg));
+ break;
+ case ARG_D_PAD_X:
+ gtk_packer_set_default_pad (packer,
+ GTK_VALUE_UINT (*arg),
+ packer->default_pad_y);
+ break;
+ case ARG_D_PAD_Y:
+ gtk_packer_set_default_pad (packer,
+ packer->default_pad_x,
+ GTK_VALUE_UINT (*arg));
+ break;
+ case ARG_D_IPAD_X:
+ gtk_packer_set_default_ipad (packer,
+ GTK_VALUE_UINT (*arg),
+ packer->default_i_pad_y);
+ break;
+ case ARG_D_IPAD_Y:
+ gtk_packer_set_default_ipad (packer,
+ packer->default_i_pad_x,
+ GTK_VALUE_UINT (*arg));
+ break;
+ default:
+ break;
+ }
+}
+
+static void
+gtk_packer_get_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id)
+{
+ GtkPacker *packer;
+
+ packer = GTK_PACKER (object);
+
+ switch (arg_id)
+ {
+ case ARG_SPACING:
+ GTK_VALUE_UINT (*arg) = packer->spacing;
+ break;
+ case ARG_D_BORDER_WIDTH:
+ GTK_VALUE_UINT (*arg) = packer->default_border_width;
+ break;
+ case ARG_D_PAD_X:
+ GTK_VALUE_UINT (*arg) = packer->default_pad_x;
+ break;
+ case ARG_D_PAD_Y:
+ GTK_VALUE_UINT (*arg) = packer->default_pad_y;
+ break;
+ case ARG_D_IPAD_X:
+ GTK_VALUE_UINT (*arg) = packer->default_i_pad_x;
+ break;
+ case ARG_D_IPAD_Y:
+ GTK_VALUE_UINT (*arg) = packer->default_i_pad_y;
+ break;
+ default:
+ arg->type = GTK_TYPE_INVALID;
+ break;
+ }
}
static GtkType
return GTK_TYPE_WIDGET;
}
+static void
+gtk_packer_set_child_arg (GtkContainer *container,
+ GtkWidget *child,
+ GtkArg *arg,
+ guint arg_id)
+{
+ GtkPacker *packer;
+ GtkPackerChild *child_info = NULL;
+
+ packer = GTK_PACKER (container);
+
+ if (arg_id != CHILD_ARG_POSITION)
+ {
+ GList *list;
+
+ list = packer->children;
+ while (list)
+ {
+ child_info = list->data;
+ if (child_info->widget == child)
+ break;
+
+ list = list->next;
+ }
+ if (!list)
+ return;
+ }
+
+ switch (arg_id)
+ {
+ case CHILD_ARG_SIDE:
+ child_info->side = GTK_VALUE_ENUM (*arg);
+ break;
+ case CHILD_ARG_ANCHOR:
+ child_info->anchor = GTK_VALUE_ENUM (*arg);
+ break;
+ case CHILD_ARG_EXPAND:
+ if (GTK_VALUE_BOOL (*arg))
+ child_info->options |= GTK_PACK_EXPAND;
+ else
+ child_info->options &= ~GTK_PACK_EXPAND;
+ break;
+ case CHILD_ARG_FILL_X:
+ if (GTK_VALUE_BOOL (*arg))
+ child_info->options |= GTK_FILL_X;
+ else
+ child_info->options &= ~GTK_FILL_X;
+ break;
+ case CHILD_ARG_FILL_Y:
+ if (GTK_VALUE_BOOL (*arg))
+ child_info->options |= GTK_FILL_Y;
+ else
+ child_info->options &= ~GTK_FILL_Y;
+ break;
+ case CHILD_ARG_USE_DEFAULT:
+ child_info->use_default = (GTK_VALUE_BOOL (*arg) != 0);
+ break;
+ case CHILD_ARG_BORDER_WIDTH:
+ if (!child_info->use_default)
+ child_info->border_width = GTK_VALUE_UINT (*arg);
+ break;
+ case CHILD_ARG_PAD_X:
+ if (!child_info->use_default)
+ child_info->pad_x = GTK_VALUE_UINT (*arg);
+ break;
+ case CHILD_ARG_PAD_Y:
+ if (!child_info->use_default)
+ child_info->pad_y = GTK_VALUE_UINT (*arg);
+ break;
+ case CHILD_ARG_I_PAD_X:
+ if (!child_info->use_default)
+ child_info->i_pad_x = GTK_VALUE_UINT (*arg);
+ break;
+ case CHILD_ARG_I_PAD_Y:
+ if (!child_info->use_default)
+ child_info->i_pad_y = GTK_VALUE_UINT (*arg);
+ break;
+ case CHILD_ARG_POSITION:
+ gtk_packer_reorder_child (packer,
+ child,
+ GTK_VALUE_LONG (*arg));
+ break;
+ default:
+ break;
+ }
+
+ if (arg_id != CHILD_ARG_POSITION &&
+ GTK_WIDGET_VISIBLE (packer) &&
+ GTK_WIDGET_VISIBLE (child))
+ gtk_widget_queue_resize (child);
+}
+
+static void
+gtk_packer_get_child_arg (GtkContainer *container,
+ GtkWidget *child,
+ GtkArg *arg,
+ guint arg_id)
+{
+ GtkPacker *packer;
+ GtkPackerChild *child_info = NULL;
+ GList * list;
+
+ packer = GTK_PACKER (container);
+
+ if (arg_id != CHILD_ARG_POSITION)
+ {
+ list = packer->children;
+ while (list)
+ {
+ child_info = list->data;
+ if (child_info->widget == child)
+ break;
+
+ list = list->next;
+ }
+ if (!list)
+ {
+ arg->type = GTK_TYPE_INVALID;
+ return;
+ }
+ }
+
+ switch (arg_id)
+ {
+ case CHILD_ARG_SIDE:
+ GTK_VALUE_ENUM (*arg) = child_info->side;
+ break;
+ case CHILD_ARG_ANCHOR:
+ GTK_VALUE_ENUM (*arg) = child_info->anchor;
+ break;
+ case CHILD_ARG_EXPAND:
+ GTK_VALUE_BOOL (*arg) = (child_info->options & GTK_PACK_EXPAND) != 0;
+ break;
+ case CHILD_ARG_FILL_X:
+ GTK_VALUE_BOOL (*arg) = (child_info->options & GTK_FILL_X) != 0;
+ break;
+ case CHILD_ARG_FILL_Y:
+ GTK_VALUE_BOOL (*arg) = (child_info->options & GTK_FILL_Y) != 0;
+ break;
+ case CHILD_ARG_USE_DEFAULT:
+ GTK_VALUE_BOOL (*arg) = child_info->use_default;
+ break;
+ case CHILD_ARG_BORDER_WIDTH:
+ GTK_VALUE_UINT (*arg) = child_info->border_width;
+ break;
+ case CHILD_ARG_PAD_X:
+ GTK_VALUE_UINT (*arg) = child_info->pad_x;
+ break;
+ case CHILD_ARG_PAD_Y:
+ GTK_VALUE_UINT (*arg) = child_info->pad_y;
+ break;
+ case CHILD_ARG_I_PAD_X:
+ GTK_VALUE_UINT (*arg) = child_info->i_pad_x;
+ break;
+ case CHILD_ARG_I_PAD_Y:
+ GTK_VALUE_UINT (*arg) = child_info->i_pad_y;
+ break;
+ case CHILD_ARG_POSITION:
+ GTK_VALUE_LONG (*arg) = 0;
+ for (list = packer->children; list; list = list->next)
+ {
+ child_info = list->data;
+ if (child_info->widget == child)
+ break;
+ GTK_VALUE_LONG (*arg)++;
+ }
+ if (!list)
+ GTK_VALUE_LONG (*arg) = -1;
+ break;
+ default:
+ arg->type = GTK_TYPE_INVALID;
+ break;
+ }
+}
+
static void
gtk_packer_init (GtkPacker *packer)
{
if (spacing != packer->spacing)
{
packer->spacing = spacing;
- gtk_widget_queue_resize(GTK_WIDGET(packer));
+ gtk_widget_queue_resize (GTK_WIDGET (packer));
}
};
GtkWidget*
gtk_packer_new (void)
{
- return GTK_WIDGET (gtk_type_new (gtk_packer_get_type ()));
+ return GTK_WIDGET (gtk_type_new (GTK_TYPE_PACKER));
}
static void
child->pad_y = packer->default_pad_y;
child->i_pad_x = packer->default_i_pad_x;
child->i_pad_y = packer->default_i_pad_y;
- gtk_widget_queue_resize(GTK_WIDGET(packer));
+ gtk_widget_queue_resize (GTK_WIDGET (child->widget));
}
list = g_list_next(list);
}
}
}
void
-gtk_packer_set_default_pad(GtkPacker *packer,
- guint pad_x,
- guint pad_y)
+gtk_packer_set_default_pad (GtkPacker *packer,
+ guint pad_x,
+ guint pad_y)
{
g_return_if_fail (packer != NULL);
g_return_if_fail (GTK_IS_PACKER (packer));
}
void
-gtk_packer_set_default_ipad(GtkPacker *packer,
- guint i_pad_x,
- guint i_pad_y)
+gtk_packer_set_default_ipad (GtkPacker *packer,
+ guint i_pad_x,
+ guint i_pad_y)
{
g_return_if_fail (packer != NULL);
g_return_if_fail (GTK_IS_PACKER (packer));
}
+void
+gtk_packer_reorder_child (GtkPacker *packer,
+ GtkWidget *child,
+ gint position)
+{
+ GList *list;
+
+ g_return_if_fail (packer != NULL);
+ g_return_if_fail (GTK_IS_PACKER (packer));
+ g_return_if_fail (child != NULL);
+
+ list = packer->children;
+ while (list)
+ {
+ GtkPackerChild *child_info;
+
+ child_info = list->data;
+ if (child_info->widget == child)
+ break;
+
+ list = list->next;
+ }
+
+ if (list && packer->children->next)
+ {
+ GList *tmp_list;
+
+ if (list->next)
+ list->next->prev = list->prev;
+ if (list->prev)
+ list->prev->next = list->next;
+ else
+ packer->children = list->next;
+
+ tmp_list = packer->children;
+ while (position && tmp_list->next)
+ {
+ position--;
+ tmp_list = tmp_list->next;
+ }
+
+ if (position)
+ {
+ tmp_list->next = list;
+ list->prev = tmp_list;
+ list->next = NULL;
+ }
+ else
+ {
+ if (tmp_list->prev)
+ tmp_list->prev->next = list;
+ else
+ packer->children = list;
+ list->prev = tmp_list->prev;
+ tmp_list->prev = list;
+ list->next = tmp_list;
+ }
+
+ if (GTK_WIDGET_VISIBLE (child) && GTK_WIDGET_VISIBLE (packer))
+ gtk_widget_queue_resize (child);
+ }
+}
+
static void
-gtk_packer_remove (GtkContainer *container, GtkWidget *widget)
+gtk_packer_remove (GtkContainer *container,
+ GtkWidget *widget)
{
GtkPacker *packer;
GtkPackerChild *child;
gtk_packer_size_request (GtkWidget *widget, GtkRequisition *requisition)
{
GtkPacker *packer;
+ GtkContainer *container;
GtkPackerChild *child;
GList *children;
gint nvis_vert_children;
g_return_if_fail (requisition != NULL);
packer = GTK_PACKER (widget);
+ container = GTK_CONTAINER (widget);
+
requisition->width = 0;
requisition->height = 0;
nvis_vert_children = 0;
children = g_list_next(children);
}
- requisition->width = MAX (maxWidth, width);
- requisition->height = MAX (maxHeight, height);
+
+ requisition->width = MAX (maxWidth, width) + 2 * container->border_width;
+ requisition->height = MAX (maxHeight, height) + 2 * container->border_width;
}
static gint
gtk_packer_size_allocate (GtkWidget *widget, GtkAllocation *allocation)
{
GtkPacker *packer;
+ GtkContainer *container;
GtkAllocation child_allocation;
GList *list;
GtkPackerChild *child;
g_return_if_fail (GTK_IS_PACKER (widget));
g_return_if_fail (allocation != NULL);
+ packer = GTK_PACKER (widget);
+ container = GTK_CONTAINER (widget);
+
x = y = 0;
widget->allocation = *allocation;
- packer = GTK_PACKER(widget);
- cavityX = widget->allocation.x;
- cavityY = widget->allocation.y;
- cavityWidth = widget->allocation.width;
- cavityHeight = widget->allocation.height;
- list = g_list_first(packer->children);
+ cavityX = widget->allocation.x + container->border_width;
+ cavityY = widget->allocation.y + container->border_width;
+ cavityWidth = widget->allocation.width - 2 * container->border_width;
+ cavityHeight = widget->allocation.height - 2 * container->border_width;
+
+ list = g_list_first (packer->children);
while (list != NULL)
{
child = list->data;
guint pad_y,
guint i_pad_x,
guint i_pad_y);
+void gtk_packer_reorder_child (GtkPacker *packer,
+ GtkWidget *child,
+ gint position);
void gtk_packer_set_spacing (GtkPacker *packer,
guint spacing);
void gtk_packer_set_default_border_width (GtkPacker *packer,
static void gtk_radio_button_clicked (GtkButton *button);
static void gtk_radio_button_draw_indicator (GtkCheckButton *check_button,
GdkRectangle *area);
-static void gtk_radio_button_set_arg (GtkRadioButton *radio_button,
+static void gtk_radio_button_set_arg (GtkObject *object,
GtkArg *arg,
guint arg_id);
-static void gtk_radio_button_get_arg (GtkRadioButton *radio_button,
+static void gtk_radio_button_get_arg (GtkObject *object,
GtkArg *arg,
guint arg_id);
}
static void
-gtk_radio_button_set_arg (GtkRadioButton *radio_button,
+gtk_radio_button_set_arg (GtkObject *object,
GtkArg *arg,
guint arg_id)
{
+ GtkRadioButton *radio_button;
+
+ radio_button = GTK_RADIO_BUTTON (object);
+
switch (arg_id)
{
GSList *slist;
}
static void
-gtk_radio_button_get_arg (GtkRadioButton *radio_button,
+gtk_radio_button_get_arg (GtkObject *object,
GtkArg *arg,
guint arg_id)
{
+ GtkRadioButton *radio_button;
+
+ radio_button = GTK_RADIO_BUTTON (object);
+
switch (arg_id)
{
default:
style->bg[GTK_STATE_SELECTED] = gtk_default_selected_bg;
style->bg[GTK_STATE_INSENSITIVE] = gtk_default_insensitive_bg;
- for (i = 0; i < 5; i++)
+ for (i = 0; i < 4; i++)
{
style->text[i] = style->fg[i];
style->base[i] = style->white;
}
+ style->base[GTK_STATE_INSENSITIVE] = gtk_default_insensitive_bg;
+ style->text[GTK_STATE_INSENSITIVE] = gtk_default_insensitive_bg;
+
for (i = 0; i < 5; i++)
style->bg_pixmap[i] = NULL;
LAST_SIGNAL
};
+enum {
+ ARG_0,
+ ARG_ACTIVE,
+ ARG_DRAW_INDICATOR
+};
+
static void gtk_toggle_button_class_init (GtkToggleButtonClass *klass);
static void gtk_toggle_button_init (GtkToggleButton *toggle_button);
static void gtk_toggle_button_clicked (GtkButton *button);
static void gtk_toggle_button_enter (GtkButton *button);
static void gtk_toggle_button_leave (GtkButton *button);
-
+static void gtk_toggle_button_set_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id);
+static void gtk_toggle_button_get_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id);
+
static guint toggle_button_signals[LAST_SIGNAL] = { 0 };
sizeof (GtkToggleButtonClass),
(GtkClassInitFunc) gtk_toggle_button_class_init,
(GtkObjectInitFunc) gtk_toggle_button_init,
- (GtkArgSetFunc) NULL,
- (GtkArgGetFunc) NULL,
+ (GtkArgSetFunc) gtk_toggle_button_set_arg,
+ (GtkArgGetFunc) gtk_toggle_button_get_arg,
};
toggle_button_type = gtk_type_unique (gtk_button_get_type (), &toggle_button_info);
container_class = (GtkContainerClass*) class;
button_class = (GtkButtonClass*) class;
+ gtk_object_add_arg_type ("GtkToggleButton::active", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_ACTIVE);
+ gtk_object_add_arg_type ("GtkToggleButton::draw_indicator", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_DRAW_INDICATOR);
+
toggle_button_signals[TOGGLED] =
gtk_signal_new ("toggled",
GTK_RUN_FIRST,
return toggle_button;
}
+static void
+gtk_toggle_button_set_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id)
+{
+ GtkToggleButton *tb;
+
+ tb = GTK_TOGGLE_BUTTON (object);
+
+ switch (arg_id)
+ {
+ case ARG_ACTIVE:
+ gtk_toggle_button_set_state (tb, GTK_VALUE_BOOL (*arg));
+ break;
+ case ARG_DRAW_INDICATOR:
+ gtk_toggle_button_set_mode (tb, GTK_VALUE_BOOL (*arg));
+ break;
+ default:
+ break;
+ }
+}
+
+static void
+gtk_toggle_button_get_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id)
+{
+ GtkToggleButton *tb;
+
+ tb = GTK_TOGGLE_BUTTON (object);
+
+ switch (arg_id)
+ {
+ case ARG_ACTIVE:
+ GTK_VALUE_BOOL (*arg) = tb->active;
+ break;
+ case ARG_DRAW_INDICATOR:
+ GTK_VALUE_BOOL (*arg) = tb->draw_indicator;
+ break;
+ default:
+ arg->type = GTK_TYPE_INVALID;
+ break;
+ }
+}
+
void
gtk_toggle_button_set_mode (GtkToggleButton *toggle_button,
gint draw_indicator)
gpointer client_data);
extern GtkArg* gtk_object_collect_args (guint *nargs,
+ GtkType (*) (const gchar*),
va_list args1,
va_list args2);
va_start (args1, type);
va_start (args2, type);
- args = gtk_object_collect_args (&nargs, args1, args2);
+ args = gtk_object_collect_args (&nargs, gtk_object_get_arg_type, args1, args2);
gtk_object_setv (obj, nargs, args);
g_free (args);
va_start (args1, widget);
va_start (args2, widget);
- args = gtk_object_collect_args (&nargs, args1, args2);
+ args = gtk_object_collect_args (&nargs, gtk_object_get_arg_type, args1, args2);
gtk_object_setv (GTK_OBJECT (widget), nargs, args);
g_free (args);
GTK_TOGGLE_BUTTON(checkbutton)->active);
}
+static void
+entry_toggle_sensitive (GtkWidget *checkbutton,
+ GtkWidget *entry)
+{
+ gtk_widget_set_sensitive (entry, GTK_TOGGLE_BUTTON(checkbutton)->active);
+}
+
static void
entry_toggle_visibility (GtkWidget *checkbutton,
GtkWidget *entry)
GtkWidget *box1;
GtkWidget *box2;
GtkWidget *editable_check;
+ GtkWidget *sensitive_check;
GtkWidget *entry, *cb;
GtkWidget *button;
GtkWidget *separator;
entry = gtk_entry_new ();
gtk_entry_set_text (GTK_ENTRY (entry), "hello world");
- gtk_editable_select_region (GTK_EDITABLE (entry), 0, -1);
+ gtk_editable_select_region (GTK_EDITABLE (entry), 0, 5);
gtk_box_pack_start (GTK_BOX (box2), entry, TRUE, TRUE, 0);
gtk_widget_show (entry);
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(editable_check), TRUE);
gtk_widget_show (editable_check);
+ sensitive_check = gtk_check_button_new_with_label("Sensitive");
+ gtk_box_pack_start (GTK_BOX (box2), sensitive_check, FALSE, TRUE, 0);
+ gtk_signal_connect (GTK_OBJECT(sensitive_check), "toggled",
+ GTK_SIGNAL_FUNC(entry_toggle_sensitive), entry);
+ gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(sensitive_check), TRUE);
+ gtk_widget_show (sensitive_check);
+
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
gtk_widget_show (separator);
GTK_TOGGLE_BUTTON(checkbutton)->active);
}
+static void
+entry_toggle_sensitive (GtkWidget *checkbutton,
+ GtkWidget *entry)
+{
+ gtk_widget_set_sensitive (entry, GTK_TOGGLE_BUTTON(checkbutton)->active);
+}
+
static void
entry_toggle_visibility (GtkWidget *checkbutton,
GtkWidget *entry)
GtkWidget *box1;
GtkWidget *box2;
GtkWidget *editable_check;
+ GtkWidget *sensitive_check;
GtkWidget *entry, *cb;
GtkWidget *button;
GtkWidget *separator;
entry = gtk_entry_new ();
gtk_entry_set_text (GTK_ENTRY (entry), "hello world");
- gtk_editable_select_region (GTK_EDITABLE (entry), 0, -1);
+ gtk_editable_select_region (GTK_EDITABLE (entry), 0, 5);
gtk_box_pack_start (GTK_BOX (box2), entry, TRUE, TRUE, 0);
gtk_widget_show (entry);
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(editable_check), TRUE);
gtk_widget_show (editable_check);
+ sensitive_check = gtk_check_button_new_with_label("Sensitive");
+ gtk_box_pack_start (GTK_BOX (box2), sensitive_check, FALSE, TRUE, 0);
+ gtk_signal_connect (GTK_OBJECT(sensitive_check), "toggled",
+ GTK_SIGNAL_FUNC(entry_toggle_sensitive), entry);
+ gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(sensitive_check), TRUE);
+ gtk_widget_show (sensitive_check);
+
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
gtk_widget_show (separator);
projects / gtk4.git / commitdiff